package xaj.scc.ast;

import polyglot.ast.JL;
import abc.aspectj.ast.AJAbstractDelFactory_c;

public abstract class SCAbstractDelFactory_c extends AJAbstractDelFactory_c 
                                                      implements SCDelFactory {
	
	private SCAbstractDelFactory_c nextDelFactory;
	
	protected SCAbstractDelFactory_c() {
		this(null);
	}
	
	protected SCAbstractDelFactory_c(SCAbstractDelFactory_c nextDelFactory) {
		super(nextDelFactory);
		this.nextDelFactory = nextDelFactory;
	}
	
	public final JL delSyntaxClassDecl() {
		JL e = delSyntaxClassDeclImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSyntaxClassDecl();
            e = composeDels(e, e2);
        }
        return postDelSyntaxClassDecl(e);
	}
	
	protected JL delSyntaxClassDeclImpl() {
		return delAJClassDeclImpl();
	}
	
	protected JL postDelSyntaxClassDecl(JL e) {
		return postDelAJClassDecl(e);
	}
	
	public final JL delSyntaxClassBody() {
		JL e = delSyntaxClassBodyImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSyntaxClassBody();
            e = composeDels(e, e2);
        }
        return postDelSyntaxClassBody(e);
	}
	
	protected JL delSyntaxClassBodyImpl() {
		return delAJClassBodyImpl();
	}
	
	protected JL postDelSyntaxClassBody(JL e) {
		return postDelAJClassBody(e);
	}
	
	public final JL delNumberOfPasses() {
		JL e = delNumberOfPassesImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delNumberOfPasses();
            e = composeDels(e, e2);
        }
        return postDelNumberOfPasses(e);
	}
	
	protected JL delNumberOfPassesImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelNumberOfPasses(JL e) {
		return postDelNode(e);
	}	
	
	public final JL delSyntaxDeclarationInsertion() {
		JL e = delSyntaxDeclarationInsertionImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSyntaxDeclarationInsertion();
            e = composeDels(e, e2);
        }
        return postDelSyntaxDeclarationInsertion(e);
	}
	
	protected JL delSyntaxDeclarationInsertionImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelSyntaxDeclarationInsertion(JL e) {
		return postDelNode(e);
	}	
	
	public final JL delSyntaxDeclarationOverrides() {
		JL e = delSyntaxDeclarationOverridesImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSyntaxDeclarationOverrides();
            e = composeDels(e, e2);
        }
        return postDelSyntaxDeclarationOverrides(e);
	}
	
	protected JL delSyntaxDeclarationOverridesImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelSyntaxDeclarationOverrides(JL e) {
		return postDelNode(e);
	}
	
	public final JL delProduction() {
		JL e = delProductionImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delProduction();
            e = composeDels(e, e2);
        }
        return postDelProduction(e);
	}
	
	protected JL delProductionImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelProduction(JL e) {
		return postDelNode(e);
	}
	
	public final JL delProductionElement() {
		JL e = delProductionElementImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delProductionElement();
            e = composeDels(e, e2);
        }
        return postDelProductionElement(e);
	}
	
	protected JL delProductionElementImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelProductionElement(JL e) {
		return postDelNode(e);
	}
	
	public final JL delSimpleFactor() {
		JL e = delSimpleFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSimpleFactor();
            e = composeDels(e, e2);
        }
        return postDelSimpleFactor(e);
	}
	
	protected JL delSimpleFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelSimpleFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delStringFactor() {
		JL e = delStringFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delStringFactor();
            e = composeDels(e, e2);
        }
        return postDelStringFactor(e);
	}
	
	protected JL delStringFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelStringFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delOptionalFactor() {
		JL e = delOptionalFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delOptionalFactor();
            e = composeDels(e, e2);
        }
        return postDelOptionalFactor(e);
	}
	
	protected JL postDelOptionalFactor(JL e) {
		return postDelNode(e);
	}
	
	protected JL delOptionalFactorImpl() {
		return delNodeImpl();
	}
	
	public final JL delOrFactor() {
		JL e = delOrFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delOrFactor();
            e = composeDels(e, e2);
        }
        return postDelOrFactor(e);
	}
	
	protected JL delOrFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelOrFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delConcatFactor() {
		JL e = delConcatFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delConcatFactor();
            e = composeDels(e, e2);
        }
        return postDelConcatFactor(e);
	}
	
	protected JL delConcatFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelConcatFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delLambdaFactor(){
		JL e = delLambdaFactorImpl();
		
		if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delLambdaFactor();
            e = composeDels(e, e2);
        }
		
		return postDelLambdaFactor(e);
		
	}
	
	protected JL delLambdaFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelLambdaFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delClosureFactor() {
		JL e = delClosureFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delClosureFactor();
            e = composeDels(e, e2);
        }
        return postDelClosureFactor(e);
	}
	
	protected JL delClosureFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelClosureFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delNamedFactor() {
		JL e = delNamedFactorImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delNamedFactor();
            e = composeDels(e, e2);
        }
        return postDelNamedFactor(e);
	}
	
	protected JL delNamedFactorImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelNamedFactor(JL e) {
		return postDelNode(e);
	}
	
	public final JL delSemanticAction() {
		JL e = delSemanticActionImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delSemanticAction();
            e = composeDels(e, e2);
        }
        return postDelSemanticAction(e);
	}
	
	protected JL delSemanticActionImpl() {
		return delNodeImpl();
	}
	
	protected JL postDelSemanticAction(JL e) {
		return postDelNode(e);
	}
	
	public final JL delImportSymbol() {
		JL e = delImportSymbolImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delImportSymbol();
            e = composeDels(e, e2);
        }
        return postDelImportSymbol(e);
	}
	
	protected JL delImportSymbolImpl() {
		return delImportImpl();
	}
	
	protected JL postDelImportSymbol(JL e) {
		return postDelImport(e);
	}
	
	public final JL delImportSyntax() {
		JL e = delImportSyntaxImpl();

        if (nextDelFactory != null) {
            JL e2 = nextDelFactory.delImportSyntax();
            e = composeDels(e, e2);
        }
        return postDelImportSyntax(e);
	}
	
	protected JL delImportSyntaxImpl() {
		return delImportImpl();
	}
	
	protected JL postDelImportSyntax(JL e) {
		return postDelImport(e);
	}
	
	/*public JL delOnWeaving() {
		return delImportImpl();
	}*/
	
}
